home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr47 / 335_02.zip / AS6809.Y < prev    next >
Text File  |  1993-04-01  |  51KB  |  2,204 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     as6809.y;
  13. WARNINGS:     "This software is in the public domain.  
  14.         Any prior copyright claims are relinquished.  
  15.  
  16.         This software is distributed with no warranty whatever.  
  17.         The author takes no responsibility for the consequences 
  18.         of its use.
  19.  
  20.         Yacc (or Bison) required to compile."  ;
  21. SEE-ALSO:     as6809.doc,frasmain.c;    
  22. AUTHORS:     Mark Zenier;
  23. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  24.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  25. */
  26. /* 6809 instruction generation file */
  27. /* November 17, 1990 */
  28.  
  29. /*
  30.     description    frame work parser description for framework cross
  31.             assemblers
  32.     history        February 2, 1988
  33.             September 11, 1990 - merge table definition
  34.             September 12, 1990 - short file names
  35.             September 14, 1990 - short variable names
  36.             September 17, 1990 - use yylex as external
  37. */
  38. #include <stdio.h>
  39. #include "frasmdat.h"
  40. #include "fragcon.h"
  41.  
  42. #define yylex lexintercept
  43.  
  44.     /* select criteria for ST_EXP  0000.0000.0000.00xx */
  45. #define    ADDR    0x3
  46. #define    DIRECT    0x1
  47. #define    EXTENDED    0x2
  48. #define ST_INH 0x1
  49. #define ST_IMM 0x2
  50. #define ST_EXP 0x4
  51. #define ST_IND 0x8
  52. #define ST_PCR 0x10
  53. #define ST_IPCR 0x20
  54. #define ST_IEXPR 0x40
  55. #define ST_SPSH 0x1
  56. #define ST_UPSH 0x1
  57. #define ST_TFR 0x1
  58.     
  59.     static char    genbdef[] = "[1=];";
  60.     static char    genwdef[] = "[1=]x"; /* x for normal, y for byte rev */
  61.     char ignosyn[] = "[Xinvalid syntax for instruction";
  62.     char ignosel[] = "[Xinvalid operands";
  63. #define    IDM000    0
  64. #define    IDM100    1
  65. #define    IDM101    2
  66. #define    IDM102    3
  67. #define    IDM103    4
  68. #define    IDM104    5
  69. #define    IDM105    6
  70. #define    IDM106    7
  71. #define    IDM108    8
  72. #define    IDM109    9
  73. #define    IDM10B    10
  74. #define    IDM111    11
  75. #define    IDM113    12
  76. #define    IDM114    13
  77. #define    IDM115    14
  78. #define    IDM116    15
  79. #define    IDM118    16
  80. #define    IDM119    17
  81. #define    IDM11B    18
  82.     char *(indexgen [] [4]) = {
  83. /*IDM000;*/ { "[1=].5R.00|;", "[1=].5R.20|;", "[1=].5R.40|;", "[1=].5R.60|;"},
  84. /*IDM100;*/ { "80;", "a0;", "c0;", "e0;" },
  85. /*IDM101;*/ { "81;", "a1;", "c1;", "e1;" },
  86. /*IDM102;*/ { "82;", "a2;", "c2;", "e2;" },
  87. /*IDM103;*/ { "83;", "a3;", "c3;", "e3;" },
  88. /*IDM104;*/ { "84;", "a4;", "c4;", "e4;" },
  89. /*IDM105;*/ { "85;", "a5;", "c5;", "e5;" },
  90. /*IDM106;*/ { "86;", "a6;", "c6;", "e6;" },
  91. /*IDM108;*/ { "88;[1=]r", "a8;[1=]r", "c8;[1=]r", "e8;[1=]r" },
  92. /*IDM109;*/ { "89;[1=]x", "a9;[1=]x", "c9;[1=]x", "e9;[1=]x" },
  93. /*IDM10B;*/ { "8B;", "aB;", "cB;", "eB;" },
  94. /*IDM111;*/ { "91;", "B1;", "D1;", "F1;" },
  95. /*IDM113;*/ { "93;", "B3;", "D3;", "F3;" },
  96. /*IDM114;*/ { "94;", "B4;", "D4;", "F4;" },
  97. /*IDM115;*/ { "95;", "B5;", "D5;", "F5;" },
  98. /*IDM116;*/ { "96;", "B6;", "D6;", "F6;" },
  99. /*IDM118;*/ { "98;[1=]r", "b8;[1=]r", "d8;[1=]r", "f8;[1=]r" },
  100. /*IDM119;*/ { "99;[1=]x", "b9;[1=]x", "d9;[1=]x", "f9;[1=]x" },
  101. /*IDM11B;*/ { "9B;", "BB;", "DB;", "FB;" }
  102.         };
  103.  
  104. #define    PCRNEG8M    -126
  105. #define    PCRPLUS8M    129
  106. #define    PCR8STR        "8c;[1=].Q.1+-r"
  107. #define    IPCR8STR    "9c;[1=].Q.1+-r"
  108. #define    PCR16STR    "8d;[1=].Q.2+-.ffff&x"
  109. #define    IPCR16STR    "9d;[1=].Q.2+-.ffff&x"
  110. #define    IEXPSTR        "9f;[1=]x"
  111. #define    TFRD    0
  112. #define    TFRX    1
  113. #define    TFRY    2
  114. #define    TFRU    3
  115. #define    TFRS    4
  116. #define    TFRPC    5
  117. #define    TFRA    0x8
  118. #define    TFRB    0x9
  119. #define    TFRCC    0xa
  120. #define    TFRDP    0xb
  121. #define    TFR8BIT    0x8
  122. #define    REGBUSTK 0x100
  123. #define    REGBSSTK 0x200
  124. #define    PPOSTCC    0x01
  125. #define    PPOSTA    0x02
  126. #define    PPOSTB    0x04
  127. #define    PPOSTDP    0x08
  128. #define    PPOSTX    0x10
  129. #define    PPOSTY    0x20
  130. #define    PPOSTS    (0x40|REGBSSTK)
  131. #define    PPOSTU    (0x40|REGBUSTK)
  132. #define    PPOSTPC    0x80
  133.  
  134.     long    labelloc;
  135.     static int satsub;
  136.     int    ifstkpt = 0;
  137.     int    fraifskip = FALSE;
  138.  
  139.     struct symel * endsymbol = SYMNULL;
  140.  
  141. %}
  142. %union {
  143.     int    intv;
  144.     long     longv;
  145.     char    *strng;
  146.     struct symel *symb;
  147. }
  148.  
  149. %token <intv> ACCUM
  150. %token <intv> INDEX
  151. %token <intv> SPECREG
  152. %token  PCRELATIVE
  153. %type <intv> regbits register
  154. %type <strng> indexed
  155. %token <intv> KOC_BDEF
  156. %token <intv> KOC_ELSE
  157. %token <intv> KOC_END
  158. %token <intv> KOC_ENDI
  159. %token <intv> KOC_EQU
  160. %token <intv> KOC_IF
  161. %token <intv> KOC_INCLUDE
  162. %token <intv> KOC_ORG
  163. %token <intv> KOC_RESM
  164. %token <intv> KOC_SDEF
  165. %token <intv> KOC_SET
  166. %token <intv> KOC_WDEF
  167. %token <intv> KOC_CHSET
  168. %token <intv> KOC_CHDEF
  169. %token <intv> KOC_CHUSE
  170. %token <intv> KOC_opcode
  171. %token <intv> KOC_sstkop
  172. %token <intv> KOC_ustkop
  173. %token <intv> KOC_tfrop
  174.  
  175. %token <longv> CONSTANT
  176. %token EOL
  177. %token KEOP_AND
  178. %token KEOP_DEFINED
  179. %token KEOP_EQ
  180. %token KEOP_GE
  181. %token KEOP_GT
  182. %token KEOP_HIGH
  183. %token KEOP_LE
  184. %token KEOP_LOW
  185. %token KEOP_LT
  186. %token KEOP_MOD
  187. %token KEOP_MUN
  188. %token KEOP_NE
  189. %token KEOP_NOT
  190. %token KEOP_OR
  191. %token KEOP_SHL
  192. %token KEOP_SHR
  193. %token KEOP_XOR
  194. %token KEOP_locctr
  195. %token <symb> LABEL
  196. %token <strng> STRING
  197. %token <symb> SYMBOL
  198.  
  199. %token KTK_invalid
  200.  
  201. %right    KEOP_HIGH KEOP_LOW
  202. %left    KEOP_OR KEOP_XOR
  203. %left    KEOP_AND
  204. %right    KEOP_NOT
  205. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  206. %left    '+' '-'
  207. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  208. %right    KEOP_MUN
  209.  
  210.  
  211. %type <intv> expr exprlist stringlist
  212.  
  213. %start file
  214.  
  215. %%
  216.  
  217. file    :    file allline
  218.     |    allline
  219.     ;
  220.  
  221. allline    :     line EOL
  222.             {
  223.                 clrexpr();
  224.             }
  225.     |    EOL
  226.     |    error EOL
  227.             {
  228.                 clrexpr();
  229.                 yyerrok;
  230.             }
  231.     ;
  232.  
  233. line    :    LABEL KOC_END 
  234.             {
  235.                 endsymbol = $1;
  236.                 nextreadact = Nra_end;
  237.             }
  238.     |          KOC_END 
  239.             {
  240.                 nextreadact = Nra_end;
  241.             }
  242.     |    KOC_INCLUDE STRING
  243.             {
  244.         if(nextfstk >= FILESTKDPTH)
  245.         {
  246.             fraerror("include file nesting limit exceeded");
  247.         }
  248.         else
  249.         {
  250.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  251.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  252.                 ==(FILE *)NULL )
  253.             {
  254.                 fraerror("cannot open include file");
  255.             }
  256.             else
  257.             {
  258.                 nextreadact = Nra_new;
  259.             }
  260.         }
  261.             }
  262.     |    LABEL KOC_EQU expr 
  263.             {
  264.                 if($1 -> seg == SSG_UNDEF)
  265.                 {
  266.                     pevalexpr(0, $3);
  267.                     if(evalr[0].seg == SSG_ABS)
  268.                     {
  269.                         $1 -> seg = SSG_EQU;
  270.                         $1 -> value = evalr[0].value;
  271.                         prtequvalue("C: 0x%lx\n",
  272.                             evalr[0].value);
  273.                     }
  274.                     else
  275.                     {
  276.                         fraerror(
  277.                     "noncomputable expression for EQU");
  278.                     }
  279.                 }
  280.                 else
  281.                 {
  282.                     fraerror(
  283.                 "cannot change symbol value with EQU");
  284.                 }
  285.             }
  286.     |    LABEL KOC_SET expr 
  287.             {
  288.                 if($1 -> seg == SSG_UNDEF
  289.                    || $1 -> seg == SSG_SET)
  290.                 {
  291.                     pevalexpr(0, $3);
  292.                     if(evalr[0].seg == SSG_ABS)
  293.                     {
  294.                         $1 -> seg = SSG_SET;
  295.                         $1 -> value = evalr[0].value;
  296.                         prtequvalue("C: 0x%lx\n",
  297.                             evalr[0].value);
  298.                     }
  299.                     else
  300.                     {
  301.                         fraerror(
  302.                     "noncomputable expression for SET");
  303.                     }
  304.                 }
  305.                 else
  306.                 {
  307.                     fraerror(
  308.                 "cannot change symbol value with SET");
  309.                 }
  310.             }
  311.     |    KOC_IF expr 
  312.             {
  313.         if((++ifstkpt) < IFSTKDEPTH)
  314.         {
  315.             pevalexpr(0, $2);
  316.             if(evalr[0].seg == SSG_ABS)
  317.             {
  318.                 if(evalr[0].value != 0)
  319.                 {
  320.                     elseifstk[ifstkpt] = If_Skip;
  321.                     endifstk[ifstkpt] = If_Active;
  322.                 }
  323.                 else
  324.                 {
  325.                     fraifskip = TRUE;
  326.                     elseifstk[ifstkpt] = If_Active;
  327.                     endifstk[ifstkpt] = If_Active;
  328.                 }
  329.             }
  330.             else
  331.             {
  332.                 fraifskip = TRUE;
  333.                 elseifstk[ifstkpt] = If_Active;
  334.                 endifstk[ifstkpt] = If_Active;
  335.             }
  336.         }
  337.         else
  338.         {
  339.             fraerror("IF stack overflow");
  340.         }
  341.             }
  342.                         
  343.     |    KOC_IF 
  344.             {
  345.         if(fraifskip) 
  346.         {
  347.             if((++ifstkpt) < IFSTKDEPTH)
  348.             {
  349.                     elseifstk[ifstkpt] = If_Skip;
  350.                     endifstk[ifstkpt] = If_Skip;
  351.             }
  352.             else
  353.             {
  354.                 fraerror("IF stack overflow");
  355.             }
  356.         }
  357.         else
  358.         {
  359.             yyerror("syntax error");
  360.             YYERROR;
  361.         }
  362.                 }
  363.                         
  364.     |    KOC_ELSE 
  365.             {
  366.                 switch(elseifstk[ifstkpt])
  367.                 {
  368.                 case If_Active:
  369.                     fraifskip = FALSE;
  370.                     break;
  371.                 
  372.                 case If_Skip:
  373.                     fraifskip = TRUE;
  374.                     break;
  375.                 
  376.                 case If_Err:
  377.                     fraerror("ELSE with no matching if");
  378.                     break;
  379.                 }
  380.             }
  381.  
  382.     |    KOC_ENDI 
  383.             {
  384.                 switch(endifstk[ifstkpt])
  385.                 {
  386.                 case If_Active:
  387.                     fraifskip = FALSE;
  388.                     ifstkpt--;
  389.                     break;
  390.                 
  391.                 case If_Skip:
  392.                     fraifskip = TRUE;
  393.                     ifstkpt--;
  394.                     break;
  395.                 
  396.                 case If_Err:
  397.                     fraerror("ENDI with no matching if");
  398.                     break;
  399.                 }
  400.             }
  401.     |    LABEL KOC_ORG expr 
  402.             {
  403.                 pevalexpr(0, $3);
  404.                 if(evalr[0].seg == SSG_ABS)
  405.                 {
  406.                     locctr = labelloc = evalr[0].value;
  407.                     if($1 -> seg == SSG_UNDEF)
  408.                     {
  409.                         $1 -> seg = SSG_ABS;
  410.                         $1 -> value = labelloc;
  411.                     }
  412.                     else
  413.                         fraerror(
  414.                         "multiple definition of label");
  415.                     prtequvalue("C: 0x%lx\n",
  416.                         evalr[0].value);
  417.                 }
  418.                 else
  419.                 {
  420.                     fraerror(
  421.                      "noncomputable expression for ORG");
  422.                 }
  423.             }
  424.     |          KOC_ORG expr 
  425.             {
  426.                 pevalexpr(0, $2);
  427.                 if(evalr[0].seg == SSG_ABS)
  428.                 {
  429.                     locctr = labelloc = evalr[0].value;
  430.                     prtequvalue("C: 0x%lx\n",
  431.                         evalr[0].value);
  432.                 }
  433.                 else
  434.                 {
  435.                     fraerror(
  436.                      "noncomputable expression for ORG");
  437.                 }
  438.             }
  439.     |    LABEL KOC_CHSET
  440.             {
  441.                 if($1 -> seg == SSG_UNDEF)
  442.                 {
  443.                     $1 -> seg = SSG_EQU;
  444.                     if( ($1->value = chtcreate()) <= 0)
  445.                     {
  446.         fraerror( "cannot create character translation table");
  447.                     }
  448.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  449.                 }
  450.                 else
  451.                 {
  452.             fraerror( "multiple definition of label");
  453.                 }
  454.             }
  455.     |        KOC_CHUSE
  456.             {
  457.                 chtcpoint = (int *) NULL;
  458.                 prtequvalue("C: 0x%lx\n", 0L);
  459.             }
  460.     |        KOC_CHUSE expr
  461.             {
  462.                 pevalexpr(0, $2);
  463.                 if( evalr[0].seg == SSG_ABS)
  464.                 {
  465.                     if( evalr[0].value == 0)
  466.                     {
  467.                         chtcpoint = (int *)NULL;
  468.                         prtequvalue("C: 0x%lx\n", 0L);
  469.                     }
  470.                     else if(evalr[0].value < chtnxalph)
  471.                     {
  472.                 chtcpoint = chtatab[evalr[0].value];
  473.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  474.                     }
  475.                     else
  476.                     {
  477.             fraerror("nonexistent character translation table");
  478.                     }
  479.                 }
  480.                 else
  481.                 {
  482.                     fraerror("noncomputable expression");
  483.                 }
  484.             }
  485.     |        KOC_CHDEF STRING ',' exprlist
  486.             {
  487.         int findrv, numret, *charaddr;
  488.         char *sourcestr = $2, *before;
  489.  
  490.         if(chtnpoint != (int *)NULL)
  491.         {
  492.             for(satsub = 0; satsub < $4; satsub++)
  493.             {
  494.                 before = sourcestr;
  495.  
  496.                 pevalexpr(0, exprlist[satsub]);
  497.                 findrv = chtcfind(chtnpoint, &sourcestr,
  498.                         &charaddr, &numret);
  499.                 if(findrv == CF_END)
  500.                 {
  501.             fraerror("more expressions than characters");
  502.                     break;
  503.                 }
  504.  
  505.                 if(evalr[0].seg == SSG_ABS)
  506.                 {
  507.                     switch(findrv)
  508.                     {
  509.                     case CF_UNDEF:
  510.                         {
  511.                 if(evalr[0].value < 0 ||
  512.                     evalr[0].value > 255)
  513.                 {
  514.             frawarn("character translation value truncated");
  515.                 }
  516.                 *charaddr = evalr[0].value & 0xff;
  517.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  518.                         }
  519.                         break;
  520.  
  521.                     case CF_INVALID:
  522.                     case CF_NUMBER:
  523.                 fracherror("invalid character to define", 
  524.                     before, sourcestr);
  525.                         break;
  526.  
  527.                     case CF_CHAR:
  528.                 fracherror("character already defined", 
  529.                     before, sourcestr);
  530.                         break;
  531.                     }
  532.                 }
  533.                 else
  534.                 {
  535.                     fraerror("noncomputable expression");
  536.                 }
  537.             }
  538.  
  539.             if( *sourcestr != '\0')
  540.             {
  541.                 fraerror("more characters than expressions");
  542.             }
  543.         }
  544.         else
  545.         {
  546.             fraerror("no CHARSET statement active");
  547.         }
  548.             
  549.             }
  550.     |    LABEL 
  551.             {
  552.             if($1 -> seg == SSG_UNDEF)
  553.             {
  554.                 $1 -> seg = SSG_ABS;
  555.                 $1 -> value = labelloc;
  556.                 prtequvalue("C: 0x%lx\n", labelloc);
  557.  
  558.             }
  559.             else
  560.                 fraerror(
  561.                 "multiple definition of label");
  562.             }
  563.     |    labeledline
  564.     ;
  565.  
  566. labeledline :    LABEL genline
  567.             {
  568.             if($1 -> seg == SSG_UNDEF)
  569.             {
  570.                 $1 -> seg = SSG_ABS;
  571.                 $1 -> value = labelloc;
  572.             }
  573.             else
  574.                 fraerror(
  575.                 "multiple definition of label");
  576.             labelloc = locctr;
  577.             }
  578.                 
  579.     |    genline
  580.             {
  581.                 labelloc = locctr;
  582.             }
  583.     ;
  584.  
  585. genline    :    KOC_BDEF    exprlist 
  586.             {
  587.                 genlocrec(currseg, labelloc);
  588.                 for( satsub = 0; satsub < $2; satsub++)
  589.                 {
  590.                     pevalexpr(1, exprlist[satsub]);
  591.                     locctr += geninstr(genbdef);
  592.                 }
  593.             }
  594.     |    KOC_SDEF stringlist 
  595.             {
  596.                 genlocrec(currseg, labelloc);
  597.                 for(satsub = 0; satsub < $2; satsub++)
  598.                 {
  599.                     locctr += genstring(stringlist[satsub]);
  600.                 }
  601.             }
  602.     |    KOC_WDEF exprlist 
  603.             {
  604.                 genlocrec(currseg, labelloc);
  605.                 for( satsub = 0; satsub < $2; satsub++)
  606.                 {
  607.                     pevalexpr(1, exprlist[satsub]);
  608.                     locctr += geninstr(genwdef);
  609.                 }
  610.             }    
  611.     |    KOC_RESM expr 
  612.             {
  613.                 pevalexpr(0, $2);
  614.                 if(evalr[0].seg == SSG_ABS)
  615.                 {
  616.                     locctr = labelloc + evalr[0].value;
  617.                     prtequvalue("C: 0x%lx\n", labelloc);
  618.                 }
  619.                 else
  620.                 {
  621.                     fraerror(
  622.                  "noncomputable result for RMB expression");
  623.                 }
  624.             }
  625.     ;
  626.  
  627. exprlist :    exprlist ',' expr
  628.             {
  629.                 exprlist[nextexprs ++ ] = $3;
  630.                 $$ = nextexprs;
  631.             }
  632.     |    expr
  633.             {
  634.                 nextexprs = 0;
  635.                 exprlist[nextexprs ++ ] = $1;
  636.                 $$ = nextexprs;
  637.             }
  638.     ;
  639.  
  640. stringlist :    stringlist ',' STRING
  641.             {
  642.                 stringlist[nextstrs ++ ] = $3;
  643.                 $$ = nextstrs;
  644.             }
  645.     |    STRING
  646.             {
  647.                 nextstrs = 0;
  648.                 stringlist[nextstrs ++ ] = $1;
  649.                 $$ = nextstrs;
  650.             }
  651.     ;
  652.  
  653.  
  654. genline : KOC_opcode  
  655.             {
  656.         genlocrec(currseg, labelloc);
  657.         locctr += geninstr(findgen($1, ST_INH, 0));
  658.             }
  659.     ;
  660. genline : KOC_opcode  '#' expr
  661.             {
  662.         pevalexpr(1, $3);
  663.         genlocrec(currseg, labelloc);
  664.         locctr += geninstr( findgen($1, ST_IMM, 0));
  665.             }
  666.     ;
  667. genline : KOC_opcode  expr
  668.             {
  669.         genlocrec(currseg, labelloc);
  670.         pevalexpr(1, $2);
  671.         locctr += geninstr( findgen( $1, ST_EXP, 
  672.                   ( (evalr[1].seg == SSG_ABS 
  673.                 && evalr[1].value >= 0
  674.                 && evalr[1].value <= 255 )
  675.                 ? DIRECT : EXTENDED ) )
  676.                 );
  677.             }
  678.     ;
  679. genline : KOC_opcode  indexed
  680.             {
  681.         genlocrec(currseg, labelloc);
  682.         locctr += geninstr(findgen($1, ST_IND, 0));
  683.         locctr += geninstr($2);
  684.             }
  685.     ;
  686. genline : KOC_opcode  expr ',' PCRELATIVE
  687.             {
  688.         genlocrec(currseg, labelloc);
  689.         pevalexpr(1, $2);
  690.         locctr += geninstr(findgen($1, ST_IND, 0));
  691.         if(evalr[1].seg == SSG_ABS 
  692.             && (evalr[1].value - locctr) >= PCRNEG8M
  693.             && (evalr[1].value - locctr) <= PCRPLUS8M)
  694.         {
  695.             locctr += geninstr(PCR8STR);
  696.         }
  697.         else
  698.         {
  699.             locctr += geninstr(PCR16STR);
  700.         }
  701.             }
  702.     ;
  703. genline : KOC_opcode  '[' expr ',' PCRELATIVE ']'
  704.             {
  705.         genlocrec(currseg, labelloc);
  706.         pevalexpr(1, $3);
  707.         locctr += geninstr(findgen($1, ST_IND, 0));
  708.         if(evalr[1].seg == SSG_ABS 
  709.             && (evalr[1].value - locctr) >= PCRNEG8M
  710.             && (evalr[1].value - locctr) <= PCRPLUS8M)
  711.         {
  712.             locctr += geninstr(IPCR8STR);
  713.         }
  714.         else
  715.         {
  716.             locctr += geninstr(IPCR16STR);
  717.         }
  718.             }
  719.     ;
  720. genline : KOC_opcode  '[' expr ']'
  721.             {
  722.         genlocrec(currseg, labelloc);
  723.         pevalexpr(1, $3);
  724.         locctr += geninstr(findgen($1, ST_IND, 0));
  725.         locctr += geninstr(IEXPSTR);
  726.             }
  727.     ;
  728. genline : KOC_sstkop  regbits
  729.             {
  730.         genlocrec(currseg, labelloc);
  731.         if($2 & REGBSSTK)
  732.         {
  733.             fraerror("push/pop of system stack register");
  734.             evalr[1].value = 0;
  735.         }
  736.         else
  737.         {
  738.             evalr[1].value = $2 & 0xff;
  739.         }    
  740.         locctr += geninstr(findgen($1, ST_SPSH, 0));
  741.             }
  742.     ;
  743. genline : KOC_ustkop  regbits
  744.             {
  745.         genlocrec(currseg, labelloc);
  746.         if($2 & REGBUSTK)
  747.         {
  748.             fraerror("push/pop of user stack register");
  749.             evalr[1].value = 0;
  750.         }
  751.         else
  752.         {
  753.             evalr[1].value = $2 & 0xff;
  754.         }    
  755.         locctr += geninstr(findgen($1, ST_SPSH, 0));
  756.             }
  757.     ;
  758. genline : KOC_tfrop  register ',' register
  759.             {
  760.         genlocrec(currseg, labelloc);
  761.         if(($2 & TFR8BIT) == ($4 & TFR8BIT))
  762.         {
  763.             evalr[1].value = $2;
  764.             evalr[2].value = $4;
  765.         }
  766.         else
  767.         {
  768.             evalr[1].value = 0;
  769.             evalr[2].value = 0;
  770.             fraerror("operands are different sizes");
  771.         }
  772.         locctr += geninstr(findgen($1, ST_TFR, 0));
  773.             }
  774.     ;
  775. indexed :    expr ',' INDEX
  776.             {
  777.         pevalexpr(1, $1);
  778.         if(evalr[1].seg == SSG_ABS
  779.             && evalr[1].value >= -128
  780.             && evalr[1].value <= 127 )
  781.         {
  782.             if(evalr[1].value >= -16
  783.             && evalr[1].value <= 15)
  784.             {
  785.                 if(evalr[1].value == 0)
  786.                     $$ = indexgen [IDM104] [$3 - TFRX];
  787.                 else
  788.                     $$ = indexgen [IDM000] [$3 - TFRX];
  789.             }
  790.             else
  791.             {
  792.                 $$ = indexgen [IDM108] [$3 - TFRX];
  793.             }
  794.         }
  795.         else
  796.         {
  797.             $$ = indexgen [IDM109] [$3 - TFRX];
  798.         }
  799.             }
  800.  
  801.     |    ACCUM ',' INDEX
  802.             {
  803.         switch($1)
  804.         {
  805.         case TFRA:
  806.             $$ = indexgen [IDM106] [$3 - TFRX];
  807.             break;
  808.         case TFRB:
  809.             $$ = indexgen [IDM105] [$3 - TFRX];
  810.             break;
  811.         case TFRD:
  812.             $$ = indexgen [IDM10B] [$3 - TFRX];
  813.             break;
  814.         }
  815.             }
  816.  
  817.     |    ',' INDEX
  818.             {
  819.         $$ = indexgen [IDM104] [$2 - TFRX];
  820.             }
  821.  
  822.     |    ',' INDEX '+'
  823.             {
  824.         $$ = indexgen [IDM100] [$2 - TFRX];
  825.             }
  826.  
  827.     |    ',' INDEX '+' '+'
  828.             {
  829.         $$ = indexgen [IDM101] [$2 - TFRX];
  830.             }
  831.  
  832.     |    ',' '-' INDEX
  833.             {
  834.         $$ = indexgen [IDM102] [$3 - TFRX];
  835.             }
  836.  
  837.     |    ',' '-' '-' INDEX
  838.             {
  839.         $$ = indexgen [IDM103] [$4 - TFRX];
  840.             }
  841.  
  842.     |    '[' expr ',' INDEX ']'
  843.             {
  844.         pevalexpr(1, $2);
  845.         if(evalr[1].seg == SSG_ABS
  846.             && evalr[1].value >= -128
  847.             && evalr[1].value <= 127 )
  848.         {
  849.             if(evalr[1].value == 0)
  850.                 $$ = indexgen [IDM114] [$4 - TFRX];
  851.             else
  852.                 $$ = indexgen [IDM118] [$4 - TFRX];
  853.         }
  854.         else
  855.         {
  856.             $$ = indexgen [IDM119] [$4 - TFRX];
  857.         }
  858.             }
  859.  
  860.     |    '[' ACCUM ',' INDEX ']'
  861.             {
  862.         switch($2)
  863.         {
  864.         case TFRA:
  865.             $$ = indexgen [IDM116] [$4 - TFRX];
  866.             break;
  867.         case TFRB:
  868.             $$ = indexgen [IDM115] [$4 - TFRX];
  869.             break;
  870.         case TFRD:
  871.             $$ = indexgen [IDM11B] [$4 - TFRX];
  872.             break;
  873.         }
  874.             }
  875.  
  876.     |    '[' ',' INDEX ']'
  877.             {
  878.         $$ = indexgen [IDM114] [$3 - TFRX];
  879.             }
  880.  
  881.     |    '[' ',' INDEX '+' '+' ']'
  882.             {
  883.         $$ = indexgen [IDM111] [$3 - TFRX];
  884.             }
  885.  
  886.     |    '[' ',' '-' '-' INDEX ']'
  887.             {
  888.         $$ = indexgen [IDM113] [$5 - TFRX];
  889.             }
  890.     ;
  891.  
  892. regbits :    regbits ',' register
  893.             {
  894.         switch($3)
  895.         {
  896.         case TFRD:
  897.             $$ = $1 |  (PPOSTA | PPOSTB);
  898.             break;
  899.         case TFRX:
  900.             $$ = $1 |  PPOSTX;
  901.             break;
  902.         case TFRY:
  903.             $$ = $1 |  PPOSTY;
  904.             break;
  905.         case TFRU:
  906.             $$ = $1 |  PPOSTU;
  907.             break;
  908.         case TFRS:
  909.             $$ = $1 |  PPOSTS;
  910.             break;
  911.         case TFRPC:
  912.             $$ = $1 |  PPOSTPC;
  913.             break;
  914.         case TFRA:
  915.             $$ = $1 |  PPOSTA;
  916.             break;
  917.         case TFRB:
  918.             $$ = $1 |  PPOSTB;
  919.             break;
  920.         case TFRCC:
  921.             $$ = $1 |  PPOSTCC;
  922.             break;
  923.         case TFRDP:
  924.             $$ = $1 |  PPOSTDP;
  925.             break;
  926.         }
  927.             }
  928.     |    register
  929.             {
  930.         switch($1)
  931.         {
  932.         case TFRD:
  933.             $$ = (PPOSTA | PPOSTB);
  934.             break;
  935.         case TFRX:
  936.             $$ = PPOSTX;
  937.             break;
  938.         case TFRY:
  939.             $$ = PPOSTY;
  940.             break;
  941.         case TFRU:
  942.             $$ = PPOSTU;
  943.             break;
  944.         case TFRS:
  945.             $$ = PPOSTS;
  946.             break;
  947.         case TFRPC:
  948.             $$ = PPOSTPC;
  949.             break;
  950.         case TFRA:
  951.             $$ = PPOSTA;
  952.             break;
  953.         case TFRB:
  954.             $$ = PPOSTB;
  955.             break;
  956.         case TFRCC:
  957.             $$ = PPOSTCC;
  958.             break;
  959.         case TFRDP:
  960.             $$ = PPOSTDP;
  961.             break;
  962.         }
  963.             }
  964.     ;
  965.  
  966. register :    ACCUM
  967.     |    INDEX
  968.     |    SPECREG
  969.     ;
  970. expr    :    '+' expr %prec KEOP_MUN
  971.             {
  972.                 $$ = $2;
  973.             }
  974.     |    '-' expr %prec KEOP_MUN
  975.             {
  976.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  977.                     SYMNULL);
  978.             }
  979.     |    KEOP_NOT expr
  980.             {
  981.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  982.                     SYMNULL);
  983.             }
  984.     |    KEOP_HIGH expr
  985.             {
  986.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  987.                     SYMNULL);
  988.             }
  989.     |    KEOP_LOW expr
  990.             {
  991.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  992.                     SYMNULL);
  993.             }
  994.     |    expr '*' expr
  995.             {
  996.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  997.                     SYMNULL);
  998.             }
  999.     |    expr '/' expr
  1000.             {
  1001.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  1002.                     SYMNULL);
  1003.             }
  1004.     |    expr '+' expr
  1005.             {
  1006.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  1007.                     SYMNULL);
  1008.             }
  1009.     |    expr '-' expr
  1010.             {
  1011.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  1012.                     SYMNULL);
  1013.             }
  1014.     |    expr KEOP_MOD expr
  1015.             {
  1016.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  1017.                     SYMNULL);
  1018.             }
  1019.     |    expr KEOP_SHL expr
  1020.             {
  1021.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  1022.                     SYMNULL);
  1023.             }
  1024.     |    expr KEOP_SHR expr
  1025.             {
  1026.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  1027.                     SYMNULL);
  1028.             }
  1029.     |    expr KEOP_GT expr
  1030.             {
  1031.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  1032.                     SYMNULL);
  1033.             }
  1034.     |    expr KEOP_GE expr
  1035.             {
  1036.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  1037.                     SYMNULL);
  1038.             }
  1039.     |    expr KEOP_LT expr
  1040.             {
  1041.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  1042.                     SYMNULL);
  1043.             }
  1044.     |    expr KEOP_LE expr
  1045.             {
  1046.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  1047.                     SYMNULL);
  1048.             }
  1049.     |    expr KEOP_NE expr
  1050.             {
  1051.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  1052.                     SYMNULL);
  1053.             }
  1054.     |    expr KEOP_EQ expr
  1055.             {
  1056.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  1057.                     SYMNULL);
  1058.             }
  1059.     |    expr KEOP_AND expr
  1060.             {
  1061.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  1062.                     SYMNULL);
  1063.             }
  1064.     |    expr KEOP_OR expr
  1065.             {
  1066.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  1067.                     SYMNULL);
  1068.             }
  1069.     |    expr KEOP_XOR expr
  1070.             {
  1071.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  1072.                     SYMNULL);
  1073.             }
  1074.     |    KEOP_DEFINED SYMBOL
  1075.             {
  1076.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  1077.             }
  1078.     |    SYMBOL
  1079.             {
  1080.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  1081.             }
  1082.     |    '*'
  1083.             {
  1084.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  1085.                     labelloc, SYMNULL);
  1086.             }
  1087.     |    CONSTANT
  1088.             {
  1089.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  1090.                     SYMNULL);
  1091.             }
  1092.     |    STRING
  1093.             {
  1094.                 char *sourcestr = $1;
  1095.                 long accval = 0;
  1096.  
  1097.                 if(strlen($1) > 0)
  1098.                 {
  1099.                     accval = chtran(&sourcestr);
  1100.                     if(*sourcestr != '\0')
  1101.                     {
  1102.                         accval = (accval << 8) +
  1103.                             chtran(&sourcestr);
  1104.                     }
  1105.  
  1106.                     if( *sourcestr != '\0')
  1107.                     {
  1108.     frawarn("string constant in expression more than 2 characters long");
  1109.                     }
  1110.                 }
  1111.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  1112.                     accval, SYMNULL);
  1113.             }
  1114.     |    '(' expr ')'
  1115.             {
  1116.                 $$ = $2;
  1117.             }
  1118.     ;
  1119.  
  1120.  
  1121.  
  1122. %%
  1123.  
  1124. lexintercept()
  1125. /*
  1126.     description    intercept the call to yylex (the lexical analyzer)
  1127.             and filter out all unnecessary tokens when skipping
  1128.             the input between a failed IF and its matching ENDI or
  1129.             ELSE
  1130.     globals     fraifskip    the enable flag
  1131. */
  1132. {
  1133. #undef yylex
  1134.  
  1135.     int rv;
  1136.  
  1137.     if(fraifskip)
  1138.     {
  1139.         for(;;)
  1140.         {
  1141.  
  1142.             switch(rv = yylex())
  1143.  
  1144.             {
  1145.             case 0:
  1146.             case KOC_END:
  1147.             case KOC_IF:
  1148.             case KOC_ELSE:
  1149.             case KOC_ENDI:
  1150.             case EOL:
  1151.                 return rv;
  1152.             default:
  1153.                 break;
  1154.             }
  1155.         }
  1156.     }
  1157.     else
  1158.         return yylex();
  1159. #define yylex lexintercept
  1160. }
  1161.  
  1162.  
  1163.  
  1164. setreserved()
  1165. {
  1166.  
  1167.     reservedsym("and", KEOP_AND, 0);
  1168.     reservedsym("defined", KEOP_DEFINED,0);
  1169.     reservedsym("eq", KEOP_EQ, 0);
  1170.     reservedsym("ge", KEOP_GE, 0);
  1171.     reservedsym("gt", KEOP_GT, 0);
  1172.     reservedsym("high", KEOP_HIGH, 0);
  1173.     reservedsym("le", KEOP_LE, 0);
  1174.     reservedsym("low", KEOP_LOW, 0);
  1175.     reservedsym("lt", KEOP_LT, 0);
  1176.     reservedsym("mod", KEOP_MOD, 0);
  1177.     reservedsym("ne", KEOP_NE, 0);
  1178.     reservedsym("not", KEOP_NOT, 0);
  1179.     reservedsym("or", KEOP_OR, 0);
  1180.     reservedsym("shl", KEOP_SHL, 0);
  1181.     reservedsym("shr", KEOP_SHR, 0);
  1182.     reservedsym("xor", KEOP_XOR, 0);
  1183.     reservedsym("AND", KEOP_AND, 0);
  1184.     reservedsym("DEFINED", KEOP_DEFINED,0);
  1185.     reservedsym("EQ", KEOP_EQ, 0);
  1186.     reservedsym("GE", KEOP_GE, 0);
  1187.     reservedsym("GT", KEOP_GT, 0);
  1188.     reservedsym("HIGH", KEOP_HIGH, 0);
  1189.     reservedsym("LE", KEOP_LE, 0);
  1190.     reservedsym("LOW", KEOP_LOW, 0);
  1191.     reservedsym("LT", KEOP_LT, 0);
  1192.     reservedsym("MOD", KEOP_MOD, 0);
  1193.     reservedsym("NE", KEOP_NE, 0);
  1194.     reservedsym("NOT", KEOP_NOT, 0);
  1195.     reservedsym("OR", KEOP_OR, 0);
  1196.     reservedsym("SHL", KEOP_SHL, 0);
  1197.     reservedsym("SHR", KEOP_SHR, 0);
  1198.     reservedsym("XOR", KEOP_XOR, 0);
  1199.  
  1200.     /* machine specific token definitions */
  1201.     reservedsym("a", ACCUM, TFRA);
  1202.     reservedsym("b", ACCUM, TFRB);
  1203.     reservedsym("cc", SPECREG, TFRCC);
  1204.     reservedsym("dp", SPECREG, TFRDP);
  1205.     reservedsym("d", ACCUM, TFRD);
  1206.     reservedsym("x", INDEX, TFRX);
  1207.     reservedsym("y", INDEX, TFRY);
  1208.     reservedsym("u", INDEX, TFRU);
  1209.     reservedsym("s", INDEX, TFRS);
  1210.     reservedsym("pc", SPECREG, TFRPC);
  1211.     reservedsym("pcr", PCRELATIVE, 0);
  1212.     reservedsym("A", ACCUM, TFRA);
  1213.     reservedsym("B", ACCUM, TFRB);
  1214.     reservedsym("CC", SPECREG, TFRCC);
  1215.     reservedsym("DP", SPECREG, TFRDP);
  1216.     reservedsym("D", ACCUM, TFRD);
  1217.     reservedsym("X", INDEX, TFRX);
  1218.     reservedsym("Y", INDEX, TFRY);
  1219.     reservedsym("U", INDEX, TFRU);
  1220.     reservedsym("S", INDEX, TFRS);
  1221.     reservedsym("PC", SPECREG, TFRPC);
  1222.     reservedsym("PCR", PCRELATIVE, 0);
  1223. }
  1224.  
  1225. cpumatch(str)
  1226.     char * str;
  1227. {
  1228.     return TRUE;
  1229. }
  1230.  
  1231. /*
  1232.     description    Opcode and Instruction generation tables
  1233.     usage        Unix, framework crossassembler
  1234.     history        September 25, 1987
  1235. */
  1236.  
  1237. #define NUMOPCODE 163
  1238. #define NUMSYNBLK 226
  1239. #define NUMDIFFOP 279
  1240.  
  1241. int gnumopcode = NUMOPCODE;
  1242.  
  1243. int ophashlnk[NUMOPCODE];
  1244.  
  1245. struct opsym optab[NUMOPCODE+1]
  1246.     = {
  1247.     {"invalid", KOC_opcode, 2, 0 },
  1248.     {"ABX", KOC_opcode, 1, 2 },
  1249.     {"ADCA", KOC_opcode, 3, 3 },
  1250.     {"ADCB", KOC_opcode, 3, 6 },
  1251.     {"ADDA", KOC_opcode, 3, 9 },
  1252.     {"ADDB", KOC_opcode, 3, 12 },
  1253.     {"ADDD", KOC_opcode, 3, 15 },
  1254.     {"ANDA", KOC_opcode, 3, 18 },
  1255.     {"ANDB", KOC_opcode, 3, 21 },
  1256.     {"ANDCC", KOC_opcode, 1, 24 },
  1257.     {"ASL", KOC_opcode, 2, 25 },
  1258.     {"ASLA", KOC_opcode, 1, 27 },
  1259.     {"ASLB", KOC_opcode, 1, 28 },
  1260.     {"ASR", KOC_opcode, 2, 29 },
  1261.     {"ASRA", KOC_opcode, 1, 31 },
  1262.     {"ASRB", KOC_opcode, 1, 32 },
  1263.     {"BCC", KOC_opcode, 1, 33 },
  1264.     {"BCS", KOC_opcode, 1, 34 },
  1265.     {"BEQ", KOC_opcode, 1, 35 },
  1266.     {"BGE", KOC_opcode, 1, 36 },
  1267.     {"BGT", KOC_opcode, 1, 37 },
  1268.     {"BHI", KOC_opcode, 1, 38 },
  1269.     {"BHS", KOC_opcode, 1, 39 },
  1270.     {"BITA", KOC_opcode, 3, 40 },
  1271.     {"BITB", KOC_opcode, 3, 43 },
  1272.     {"BLE", KOC_opcode, 1, 46 },
  1273.     {"BLO", KOC_opcode, 1, 47 },
  1274.     {"BLS", KOC_opcode, 1, 48 },
  1275.     {"BLT", KOC_opcode, 1, 49 },
  1276.     {"BMI", KOC_opcode, 1, 50 },
  1277.     {"BNE", KOC_opcode, 1, 51 },
  1278.     {"BPL", KOC_opcode, 1, 52 },
  1279.     {"BRA", KOC_opcode, 1, 53 },
  1280.     {"BRN", KOC_opcode, 1, 54 },
  1281.     {"BSR", KOC_opcode, 1, 55 },
  1282.     {"BVC", KOC_opcode, 1, 56 },
  1283.     {"BVS", KOC_opcode, 1, 57 },
  1284.     {"BYTE", KOC_BDEF, 0, 0 },
  1285.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1286.     {"CHARSET", KOC_CHSET, 0, 0 },
  1287.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1288.     {"CHD", KOC_CHDEF, 0, 0 },
  1289.     {"CLR", KOC_opcode, 2, 58 },
  1290.     {"CLRA", KOC_opcode, 1, 60 },
  1291.     {"CLRB", KOC_opcode, 1, 61 },
  1292.     {"CMPA", KOC_opcode, 3, 62 },
  1293.     {"CMPB", KOC_opcode, 3, 65 },
  1294.     {"CMPD", KOC_opcode, 3, 68 },
  1295.     {"CMPS", KOC_opcode, 3, 71 },
  1296.     {"CMPU", KOC_opcode, 3, 74 },
  1297.     {"CMPX", KOC_opcode, 3, 77 },
  1298.     {"CMPY", KOC_opcode, 3, 80 },
  1299.     {"COM", KOC_opcode, 2, 83 },
  1300.     {"COMA", KOC_opcode, 1, 85 },
  1301.     {"COMB", KOC_opcode, 1, 86 },
  1302.     {"CWAI", KOC_opcode, 1, 87 },
  1303.     {"DAA", KOC_opcode, 1, 88 },
  1304.     {"DB", KOC_BDEF, 0, 0 },
  1305.     {"DEC", KOC_opcode, 2, 89 },
  1306.     {"DECA", KOC_opcode, 1, 91 },
  1307.     {"DECB", KOC_opcode, 1, 92 },
  1308.     {"DW", KOC_WDEF, 0, 0 },
  1309.     {"ELSE", KOC_ELSE, 0, 0 },
  1310.     {"END", KOC_END, 0, 0 },
  1311.     {"ENDI", KOC_ENDI, 0, 0 },
  1312.     {"EORA", KOC_opcode, 3, 93 },
  1313.     {"EORB", KOC_opcode, 3, 96 },
  1314.     {"EQU", KOC_EQU, 0, 0 },
  1315.     {"EXG", KOC_tfrop, 1, 99 },
  1316.     {"FCB", KOC_BDEF, 0, 0 },
  1317.     {"FCC", KOC_SDEF, 0, 0 },
  1318.     {"FDB", KOC_WDEF, 0, 0 },
  1319.     {"IF", KOC_IF, 0, 0 },
  1320.     {"INC", KOC_opcode, 2, 100 },
  1321.     {"INCA", KOC_opcode, 1, 102 },
  1322.     {"INCB", KOC_opcode, 1, 103 },
  1323.     {"INCL", KOC_INCLUDE, 0, 0 },
  1324.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1325.     {"JMP", KOC_opcode, 2, 104 },
  1326.     {"JSR", KOC_opcode, 2, 106 },
  1327.     {"LBCC", KOC_opcode, 1, 108 },
  1328.     {"LBCS", KOC_opcode, 1, 109 },
  1329.     {"LBEQ", KOC_opcode, 1, 110 },
  1330.     {"LBGE", KOC_opcode, 1, 111 },
  1331.     {"LBGT", KOC_opcode, 1, 112 },
  1332.     {"LBHI", KOC_opcode, 1, 113 },
  1333.     {"LBHS", KOC_opcode, 1, 114 },
  1334.     {"LBLE", KOC_opcode, 1, 115 },
  1335.     {"LBLO", KOC_opcode, 1, 116 },
  1336.     {"LBLS", KOC_opcode, 1, 117 },
  1337.     {"LBLT", KOC_opcode, 1, 118 },
  1338.     {"LBMI", KOC_opcode, 1, 119 },
  1339.     {"LBNE", KOC_opcode, 1, 120 },
  1340.     {"LBPL", KOC_opcode, 1, 121 },
  1341.     {"LBRA", KOC_opcode, 1, 122 },
  1342.     {"LBRN", KOC_opcode, 1, 123 },
  1343.     {"LBSR", KOC_opcode, 1, 124 },
  1344.     {"LBVC", KOC_opcode, 1, 125 },
  1345.     {"LBVS", KOC_opcode, 1, 126 },
  1346.     {"LDA", KOC_opcode, 3, 127 },
  1347.     {"LDB", KOC_opcode, 3, 130 },
  1348.     {"LDD", KOC_opcode, 3, 133 },
  1349.     {"LDS", KOC_opcode, 3, 136 },
  1350.     {"LDU", KOC_opcode, 3, 139 },
  1351.     {"LDX", KOC_opcode, 3, 142 },
  1352.     {"LDY", KOC_opcode, 3, 145 },
  1353.     {"LEAS", KOC_opcode, 1, 148 },
  1354.     {"LEAU", KOC_opcode, 1, 149 },
  1355.     {"LEAX", KOC_opcode, 1, 150 },
  1356.     {"LEAY", KOC_opcode, 1, 151 },
  1357.     {"LSL", KOC_opcode, 2, 152 },
  1358.     {"LSLA", KOC_opcode, 1, 154 },
  1359.     {"LSLB", KOC_opcode, 1, 155 },
  1360.     {"LSR", KOC_opcode, 2, 156 },
  1361.     {"LSRA", KOC_opcode, 1, 158 },
  1362.     {"LSRB", KOC_opcode, 1, 159 },
  1363.     {"MUL", KOC_opcode, 1, 160 },
  1364.     {"NEG", KOC_opcode, 2, 161 },
  1365.     {"NEGA", KOC_opcode, 1, 163 },
  1366.     {"NEGB", KOC_opcode, 1, 164 },
  1367.     {"NOP", KOC_opcode, 1, 165 },
  1368.     {"ORA", KOC_opcode, 3, 166 },
  1369.     {"ORB", KOC_opcode, 3, 169 },
  1370.     {"ORCC", KOC_opcode, 1, 172 },
  1371.     {"ORG", KOC_ORG, 0, 0 },
  1372.     {"PSHS", KOC_sstkop, 1, 173 },
  1373.     {"PSHU", KOC_ustkop, 1, 174 },
  1374.     {"PULS", KOC_sstkop, 1, 175 },
  1375.     {"PULU", KOC_ustkop, 1, 176 },
  1376.     {"RESERVE", KOC_RESM, 0, 0 },
  1377.     {"RMB", KOC_RESM, 0, 0 },
  1378.     {"ROL", KOC_opcode, 2, 177 },
  1379.     {"ROLA", KOC_opcode, 1, 179 },
  1380.     {"ROLB", KOC_opcode, 1, 180 },
  1381.     {"ROR", KOC_opcode, 2, 181 },
  1382.     {"RORA", KOC_opcode, 1, 183 },
  1383.     {"RORB", KOC_opcode, 1, 184 },
  1384.     {"RTI", KOC_opcode, 1, 185 },
  1385.     {"RTS", KOC_opcode, 1, 186 },
  1386.     {"SBCA", KOC_opcode, 3, 187 },
  1387.     {"SBCB", KOC_opcode, 3, 190 },
  1388.     {"SET", KOC_SET, 0, 0 },
  1389.     {"SEX", KOC_opcode, 1, 193 },
  1390.     {"STA", KOC_opcode, 2, 194 },
  1391.     {"STB", KOC_opcode, 2, 196 },
  1392.     {"STD", KOC_opcode, 2, 198 },
  1393.     {"STRING", KOC_SDEF, 0, 0 },
  1394.     {"STS", KOC_opcode, 2, 200 },
  1395.     {"STU", KOC_opcode, 2, 202 },
  1396.     {"STX", KOC_opcode, 2, 204 },
  1397.     {"STY", KOC_opcode, 2, 206 },
  1398.     {"SUBA", KOC_opcode, 3, 208 },
  1399.     {"SUBB", KOC_opcode, 3, 211 },
  1400.     {"SUBD", KOC_opcode, 3, 214 },
  1401.     {"SWI2", KOC_opcode, 1, 217 },
  1402.     {"SWI3", KOC_opcode, 1, 218 },
  1403.     {"SWI", KOC_opcode, 1, 219 },
  1404.     {"SYNC", KOC_opcode, 1, 220 },
  1405.     {"TFR", KOC_tfrop, 1, 221 },
  1406.     {"TST", KOC_opcode, 2, 222 },
  1407.     {"TSTA", KOC_opcode, 1, 224 },
  1408.     {"TSTB", KOC_opcode, 1, 225 },
  1409.     {"WORD", KOC_WDEF, 0, 0 },
  1410.     { "", 0, 0, 0 }};
  1411.  
  1412. struct opsynt ostab[NUMSYNBLK+1]
  1413.     = {
  1414. /* invalid 0 */ { 0, 1, 0 },
  1415. /* invalid 1 */ { 0xffff, 1, 1 },
  1416. /* ABX 2 */ { ST_INH, 1, 2 },
  1417. /* ADCA 3 */ { ST_EXP, 2, 3 },
  1418. /* ADCA 4 */ { ST_IMM, 1, 5 },
  1419. /* ADCA 5 */ { ST_IND, 1, 6 },
  1420. /* ADCB 6 */ { ST_EXP, 2, 7 },
  1421. /* ADCB 7 */ { ST_IMM, 1, 9 },
  1422. /* ADCB 8 */ { ST_IND, 1, 10 },
  1423. /* ADDA 9 */ { ST_EXP, 2, 11 },
  1424. /* ADDA 10 */ { ST_IMM, 1, 13 },
  1425. /* ADDA 11 */ { ST_IND, 1, 14 },
  1426. /* ADDB 12 */ { ST_EXP, 2, 15 },
  1427. /* ADDB 13 */ { ST_IMM, 1, 17 },
  1428. /* ADDB 14 */ { ST_IND, 1, 18 },
  1429. /* ADDD 15 */ { ST_EXP, 2, 19 },
  1430. /* ADDD 16 */ { ST_IMM, 1, 21 },
  1431. /* ADDD 17 */ { ST_IND, 1, 22 },
  1432. /* ANDA 18 */ { ST_EXP, 2, 23 },
  1433. /* ANDA 19 */ { ST_IMM, 1, 25 },
  1434. /* ANDA 20 */ { ST_IND, 1, 26 },
  1435. /* ANDB 21 */ { ST_EXP, 2, 27 },
  1436. /* ANDB 22 */ { ST_IMM, 1, 29 },
  1437. /* ANDB 23 */ { ST_IND, 1, 30 },
  1438. /* ANDCC 24 */ { ST_IMM, 1, 31 },
  1439. /* ASL 25 */ { ST_EXP, 2, 32 },
  1440. /* ASL 26 */ { ST_IND, 1, 34 },
  1441. /* ASLA 27 */ { ST_INH, 1, 35 },
  1442. /* ASLB 28 */ { ST_INH, 1, 36 },
  1443. /* ASR 29 */ { ST_EXP, 2, 37 },
  1444. /* ASR 30 */ { ST_IND, 1, 39 },
  1445. /* ASRA 31 */ { ST_INH, 1, 40 },
  1446. /* ASRB 32 */ { ST_INH, 1, 41 },
  1447. /* BCC 33 */ { ST_EXP, 1, 42 },
  1448. /* BCS 34 */ { ST_EXP, 1, 43 },
  1449. /* BEQ 35 */ { ST_EXP, 1, 44 },
  1450. /* BGE 36 */ { ST_EXP, 1, 45 },
  1451. /* BGT 37 */ { ST_EXP, 1, 46 },
  1452. /* BHI 38 */ { ST_EXP, 1, 47 },
  1453. /* BHS 39 */ { ST_EXP, 1, 48 },
  1454. /* BITA 40 */ { ST_EXP, 2, 49 },
  1455. /* BITA 41 */ { ST_IMM, 1, 51 },
  1456. /* BITA 42 */ { ST_IND, 1, 52 },
  1457. /* BITB 43 */ { ST_EXP, 2, 53 },
  1458. /* BITB 44 */ { ST_IMM, 1, 55 },
  1459. /* BITB 45 */ { ST_IND, 1, 56 },
  1460. /* BLE 46 */ { ST_EXP, 1, 57 },
  1461. /* BLO 47 */ { ST_EXP, 1, 58 },
  1462. /* BLS 48 */ { ST_EXP, 1, 59 },
  1463. /* BLT 49 */ { ST_EXP, 1, 60 },
  1464. /* BMI 50 */ { ST_EXP, 1, 61 },
  1465. /* BNE 51 */ { ST_EXP, 1, 62 },
  1466. /* BPL 52 */ { ST_EXP, 1, 63 },
  1467. /* BRA 53 */ { ST_EXP, 1, 64 },
  1468. /* BRN 54 */ { ST_EXP, 1, 65 },
  1469. /* BSR 55 */ { ST_EXP, 1, 66 },
  1470. /* BVC 56 */ { ST_EXP, 1, 67 },
  1471. /* BVS 57 */ { ST_EXP, 1, 68 },
  1472. /* CLR 58 */ { ST_EXP, 2, 69 },
  1473. /* CLR 59 */ { ST_IND, 1, 71 },
  1474. /* CLRA 60 */ { ST_INH, 1, 72 },
  1475. /* CLRB 61 */ { ST_INH, 1, 73 },
  1476. /* CMPA 62 */ { ST_EXP, 2, 74 },
  1477. /* CMPA 63 */ { ST_IMM, 1, 76 },
  1478. /* CMPA 64 */ { ST_IND, 1, 77 },
  1479. /* CMPB 65 */ { ST_EXP, 2, 78 },
  1480. /* CMPB 66 */ { ST_IMM, 1, 80 },
  1481. /* CMPB 67 */ { ST_IND, 1, 81 },
  1482. /* CMPD 68 */ { ST_EXP, 2, 82 },
  1483. /* CMPD 69 */ { ST_IMM, 1, 84 },
  1484. /* CMPD 70 */ { ST_IND, 1, 85 },
  1485. /* CMPS 71 */ { ST_EXP, 2, 86 },
  1486. /* CMPS 72 */ { ST_IMM, 1, 88 },
  1487. /* CMPS 73 */ { ST_IND, 1, 89 },
  1488. /* CMPU 74 */ { ST_EXP, 2, 90 },
  1489. /* CMPU 75 */ { ST_IMM, 1, 92 },
  1490. /* CMPU 76 */ { ST_IND, 1, 93 },
  1491. /* CMPX 77 */ { ST_EXP, 2, 94 },
  1492. /* CMPX 78 */ { ST_IMM, 1, 96 },
  1493. /* CMPX 79 */ { ST_IND, 1, 97 },
  1494. /* CMPY 80 */ { ST_EXP, 2, 98 },
  1495. /* CMPY 81 */ { ST_IMM, 1, 100 },
  1496. /* CMPY 82 */ { ST_IND, 1, 101 },
  1497. /* COM 83 */ { ST_EXP, 2, 102 },
  1498. /* COM 84 */ { ST_IND, 1, 104 },
  1499. /* COMA 85 */ { ST_INH, 1, 105 },
  1500. /* COMB 86 */ { ST_INH, 1, 106 },
  1501. /* CWAI 87 */ { ST_IMM, 1, 107 },
  1502. /* DAA 88 */ { ST_INH, 1, 108 },
  1503. /* DEC 89 */ { ST_EXP, 2, 109 },
  1504. /* DEC 90 */ { ST_IND, 1, 111 },
  1505. /* DECA 91 */ { ST_INH, 1, 112 },
  1506. /* DECB 92 */ { ST_INH, 1, 113 },
  1507. /* EORA 93 */ { ST_EXP, 2, 114 },
  1508. /* EORA 94 */ { ST_IMM, 1, 116 },
  1509. /* EORA 95 */ { ST_IND, 1, 117 },
  1510. /* EORB 96 */ { ST_EXP, 2, 118 },
  1511. /* EORB 97 */ { ST_IMM, 1, 120 },
  1512. /* EORB 98 */ { ST_IND, 1, 121 },
  1513. /* EXG 99 */ { ST_TFR, 1, 122 },
  1514. /* INC 100 */ { ST_EXP, 2, 123 },
  1515. /* INC 101 */ { ST_IND, 1, 125 },
  1516. /* INCA 102 */ { ST_INH, 1, 126 },
  1517. /* INCB 103 */ { ST_INH, 1, 127 },
  1518. /* JMP 104 */ { ST_EXP, 2, 128 },
  1519. /* JMP 105 */ { ST_IND, 1, 130 },
  1520. /* JSR 106 */ { ST_EXP, 2, 131 },
  1521. /* JSR 107 */ { ST_IND, 1, 133 },
  1522. /* LBCC 108 */ { ST_EXP, 1, 134 },
  1523. /* LBCS 109 */ { ST_EXP, 1, 135 },
  1524. /* LBEQ 110 */ { ST_EXP, 1, 136 },
  1525. /* LBGE 111 */ { ST_EXP, 1, 137 },
  1526. /* LBGT 112 */ { ST_EXP, 1, 138 },
  1527. /* LBHI 113 */ { ST_EXP, 1, 139 },
  1528. /* LBHS 114 */ { ST_EXP, 1, 140 },
  1529. /* LBLE 115 */ { ST_EXP, 1, 141 },
  1530. /* LBLO 116 */ { ST_EXP, 1, 142 },
  1531. /* LBLS 117 */ { ST_EXP, 1, 143 },
  1532. /* LBLT 118 */ { ST_EXP, 1, 144 },
  1533. /* LBMI 119 */ { ST_EXP, 1, 145 },
  1534. /* LBNE 120 */ { ST_EXP, 1, 146 },
  1535. /* LBPL 121 */ { ST_EXP, 1, 147 },
  1536. /* LBRA 122 */ { ST_EXP, 1, 148 },
  1537. /* LBRN 123 */ { ST_EXP, 1, 149 },
  1538. /* LBSR 124 */ { ST_EXP, 1, 150 },
  1539. /* LBVC 125 */ { ST_EXP, 1, 151 },
  1540. /* LBVS 126 */ { ST_EXP, 1, 152 },
  1541. /* LDA 127 */ { ST_EXP, 2, 153 },
  1542. /* LDA 128 */ { ST_IMM, 1, 155 },
  1543. /* LDA 129 */ { ST_IND, 1, 156 },
  1544. /* LDB 130 */ { ST_EXP, 2, 157 },
  1545. /* LDB 131 */ { ST_IMM, 1, 159 },
  1546. /* LDB 132 */ { ST_IND, 1, 160 },
  1547. /* LDD 133 */ { ST_EXP, 2, 161 },
  1548. /* LDD 134 */ { ST_IMM, 1, 163 },
  1549. /* LDD 135 */ { ST_IND, 1, 164 },
  1550. /* LDS 136 */ { ST_EXP, 2, 165 },
  1551. /* LDS 137 */ { ST_IMM, 1, 167 },
  1552. /* LDS 138 */ { ST_IND, 1, 168 },
  1553. /* LDU 139 */ { ST_EXP, 2, 169 },
  1554. /* LDU 140 */ { ST_IMM, 1, 171 },
  1555. /* LDU 141 */ { ST_IND, 1, 172 },
  1556. /* LDX 142 */ { ST_EXP, 2, 173 },
  1557. /* LDX 143 */ { ST_IMM, 1, 175 },
  1558. /* LDX 144 */ { ST_IND, 1, 176 },
  1559. /* LDY 145 */ { ST_EXP, 2, 177 },
  1560. /* LDY 146 */ { ST_IMM, 1, 179 },
  1561. /* LDY 147 */ { ST_IND, 1, 180 },
  1562. /* LEAS 148 */ { ST_IND, 1, 181 },
  1563. /* LEAU 149 */ { ST_IND, 1, 182 },
  1564. /* LEAX 150 */ { ST_IND, 1, 183 },
  1565. /* LEAY 151 */ { ST_IND, 1, 184 },
  1566. /* LSL 152 */ { ST_EXP, 2, 185 },
  1567. /* LSL 153 */ { ST_IND, 1, 187 },
  1568. /* LSLA 154 */ { ST_INH, 1, 188 },
  1569. /* LSLB 155 */ { ST_INH, 1, 189 },
  1570. /* LSR 156 */ { ST_EXP, 2, 190 },
  1571. /* LSR 157 */ { ST_IND, 1, 192 },
  1572. /* LSRA 158 */ { ST_INH, 1, 193 },
  1573. /* LSRB 159 */ { ST_INH, 1, 194 },
  1574. /* MUL 160 */ { ST_INH, 1, 195 },
  1575. /* NEG 161 */ { ST_EXP, 2, 196 },
  1576. /* NEG 162 */ { ST_IND, 1, 198 },
  1577. /* NEGA 163 */ { ST_INH, 1, 199 },
  1578. /* NEGB 164 */ { ST_INH, 1, 200 },
  1579. /* NOP 165 */ { ST_INH, 1, 201 },
  1580. /* ORA 166 */ { ST_EXP, 2, 202 },
  1581. /* ORA 167 */ { ST_IMM, 1, 204 },
  1582. /* ORA 168 */ { ST_IND, 1, 205 },
  1583. /* ORB 169 */ { ST_EXP, 2, 206 },
  1584. /* ORB 170 */ { ST_IMM, 1, 208 },
  1585. /* ORB 171 */ { ST_IND, 1, 209 },
  1586. /* ORCC 172 */ { ST_IMM, 1, 210 },
  1587. /* PSHS 173 */ { ST_SPSH, 1, 211 },
  1588. /* PSHU 174 */ { ST_UPSH, 1, 212 },
  1589. /* PULS 175 */ { ST_SPSH, 1, 213 },
  1590. /* PULU 176 */ { ST_UPSH, 1, 214 },
  1591. /* ROL 177 */ { ST_EXP, 2, 215 },
  1592. /* ROL 178 */ { ST_IND, 1, 217 },
  1593. /* ROLA 179 */ { ST_INH, 1, 218 },
  1594. /* ROLB 180 */ { ST_INH, 1, 219 },
  1595. /* ROR 181 */ { ST_EXP, 2, 220 },
  1596. /* ROR 182 */ { ST_IND, 1, 222 },
  1597. /* RORA 183 */ { ST_INH, 1, 223 },
  1598. /* RORB 184 */ { ST_INH, 1, 224 },
  1599. /* RTI 185 */ { ST_INH, 1, 225 },
  1600. /* RTS 186 */ { ST_INH, 1, 226 },
  1601. /* SBCA 187 */ { ST_EXP, 2, 227 },
  1602. /* SBCA 188 */ { ST_IMM, 1, 229 },
  1603. /* SBCA 189 */ { ST_IND, 1, 230 },
  1604. /* SBCB 190 */ { ST_EXP, 2, 231 },
  1605. /* SBCB 191 */ { ST_IMM, 1, 233 },
  1606. /* SBCB 192 */ { ST_IND, 1, 234 },
  1607. /* SEX 193 */ { ST_INH, 1, 235 },
  1608. /* STA 194 */ { ST_EXP, 2, 236 },
  1609. /* STA 195 */ { ST_IND, 1, 238 },
  1610. /* STB 196 */ { ST_EXP, 2, 239 },
  1611. /* STB 197 */ { ST_IND, 1, 241 },
  1612. /* STD 198 */ { ST_EXP, 2, 242 },
  1613. /* STD 199 */ { ST_IND, 1, 244 },
  1614. /* STS 200 */ { ST_EXP, 2, 245 },
  1615. /* STS 201 */ { ST_IND, 1, 247 },
  1616. /* STU 202 */ { ST_EXP, 2, 248 },
  1617. /* STU 203 */ { ST_IND, 1, 250 },
  1618. /* STX 204 */ { ST_EXP, 2, 251 },
  1619. /* STX 205 */ { ST_IND, 1, 253 },
  1620. /* STY 206 */ { ST_EXP, 2, 254 },
  1621. /* STY 207 */ { ST_IND, 1, 256 },
  1622. /* SUBA 208 */ { ST_EXP, 2, 257 },
  1623. /* SUBA 209 */ { ST_IMM, 1, 259 },
  1624. /* SUBA 210 */ { ST_IND, 1, 260 },
  1625. /* SUBB 211 */ { ST_EXP, 2, 261 },
  1626. /* SUBB 212 */ { ST_IMM, 1, 263 },
  1627. /* SUBB 213 */ { ST_IND, 1, 264 },
  1628. /* SUBD 214 */ { ST_EXP, 2, 265 },
  1629. /* SUBD 215 */ { ST_IMM, 1, 267 },
  1630. /* SUBD 216 */ { ST_IND, 1, 268 },
  1631. /* SWI2 217 */ { ST_INH, 1, 269 },
  1632. /* SWI3 218 */ { ST_INH, 1, 270 },
  1633. /* SWI 219 */ { ST_INH, 1, 271 },
  1634. /* SYNC 220 */ { ST_INH, 1, 272 },
  1635. /* TFR 221 */ { ST_TFR, 1, 273 },
  1636. /* TST 222 */ { ST_EXP, 2, 274 },
  1637. /* TST 223 */ { ST_IND, 1, 276 },
  1638. /* TSTA 224 */ { ST_INH, 1, 277 },
  1639. /* TSTB 225 */ { ST_INH, 1, 278 },
  1640.     { 0, 0, 0 } };
  1641.  
  1642. struct igel igtab[NUMDIFFOP+1]
  1643.     = {
  1644. /* invalid 0 */   { 0 , 0, 
  1645.         "[Xnullentry" },
  1646. /* invalid 1 */   { 0 , 0, 
  1647.         "[Xinvalid opcode" },
  1648. /* ABX 2 */   { 0 , 0, 
  1649.         "3a;" },
  1650. /* ADCA 3 */   { ADDR , DIRECT, 
  1651.         "99;[1=];" },
  1652. /* ADCA 4 */   { ADDR , EXTENDED, 
  1653.         "b9;[1=]x" },
  1654. /* ADCA 5 */   { 0 , 0, 
  1655.         "89;[1=];" },
  1656. /* ADCA 6 */   { 0 , 0, 
  1657.         "a9;" },
  1658. /* ADCB 7 */   { ADDR , DIRECT, 
  1659.         "d9;[1=];" },
  1660. /* ADCB 8 */   { ADDR , EXTENDED, 
  1661.         "f9;[1=]x" },
  1662. /* ADCB 9 */   { 0 , 0, 
  1663.         "c9;[1=];" },
  1664. /* ADCB 10 */   { 0 , 0, 
  1665.         "e9;" },
  1666. /* ADDA 11 */   { ADDR , DIRECT, 
  1667.         "9b;[1=];" },
  1668. /* ADDA 12 */   { ADDR , EXTENDED, 
  1669.         "bb;[1=]x" },
  1670. /* ADDA 13 */   { 0 , 0, 
  1671.         "8b;[1=];" },
  1672. /* ADDA 14 */   { 0 , 0, 
  1673.         "ab;" },
  1674. /* ADDB 15 */   { ADDR , DIRECT, 
  1675.         "db;[1=];" },
  1676. /* ADDB 16 */   { ADDR , EXTENDED, 
  1677.         "fb;[1=]x" },
  1678. /* ADDB 17 */   { 0 , 0, 
  1679.         "cb;[1=];" },
  1680. /* ADDB 18 */   { 0 , 0, 
  1681.         "eb;" },
  1682. /* ADDD 19 */   { ADDR , DIRECT, 
  1683.         "d3;[1=];" },
  1684. /* ADDD 20 */   { ADDR , EXTENDED, 
  1685.         "f3;[1=]x" },
  1686. /* ADDD 21 */   { 0 , 0, 
  1687.         "c3;[1=]x" },
  1688. /* ADDD 22 */   { 0 , 0, 
  1689.         "e3;" },
  1690. /* ANDA 23 */   { ADDR , DIRECT, 
  1691.         "94;[1=];" },
  1692. /* ANDA 24 */   { ADDR , EXTENDED, 
  1693.         "b4;[1=]x" },
  1694. /* ANDA 25 */   { 0 , 0, 
  1695.         "84;[1=];" },
  1696. /* ANDA 26 */   { 0 , 0, 
  1697.         "a4;" },
  1698. /* ANDB 27 */   { ADDR , DIRECT, 
  1699.         "d4;[1=];" },
  1700. /* ANDB 28 */   { ADDR , EXTENDED, 
  1701.         "f4;[1=]x" },
  1702. /* ANDB 29 */   { 0 , 0, 
  1703.         "c4;[1=];" },
  1704. /* ANDB 30 */   { 0 , 0, 
  1705.         "e4;" },
  1706. /* ANDCC 31 */   { 0 , 0, 
  1707.         "1c;[1=];" },
  1708. /* ASL 32 */   { ADDR , DIRECT, 
  1709.         "08;[1=];" },
  1710. /* ASL 33 */   { ADDR , EXTENDED, 
  1711.         "78;[1=]x" },
  1712. /* ASL 34 */   { 0 , 0, 
  1713.         "68;" },
  1714. /* ASLA 35 */   { 0 , 0, 
  1715.         "48;" },
  1716. /* ASLB 36 */   { 0 , 0, 
  1717.         "58;" },
  1718. /* ASR 37 */   { ADDR , DIRECT, 
  1719.         "07;[1=];" },
  1720. /* ASR 38 */   { ADDR , EXTENDED, 
  1721.         "77;[1=]x" },
  1722. /* ASR 39 */   { 0 , 0, 
  1723.         "67;" },
  1724. /* ASRA 40 */   { 0 , 0, 
  1725.         "47;" },
  1726. /* ASRB 41 */   { 0 , 0, 
  1727.         "57;" },
  1728. /* BCC 42 */   { 0 , 0, 
  1729.         "24;[1=].Q.1+-r" },
  1730. /* BCS 43 */   { 0 , 0, 
  1731.         "25;[1=].Q.1+-r" },
  1732. /* BEQ 44 */   { 0 , 0, 
  1733.         "27;[1=].Q.1+-r" },
  1734. /* BGE 45 */   { 0 , 0, 
  1735.         "2c;[1=].Q.1+-r" },
  1736. /* BGT 46 */   { 0 , 0, 
  1737.         "2e;[1=].Q.1+-r" },
  1738. /* BHI 47 */   { 0 , 0, 
  1739.         "22;[1=].Q.1+-r" },
  1740. /* BHS 48 */   { 0 , 0, 
  1741.         "24;[1=].Q.1+-r" },
  1742. /* BITA 49 */   { ADDR , DIRECT, 
  1743.         "95;[1=];" },
  1744. /* BITA 50 */   { ADDR , EXTENDED, 
  1745.         "b5;[1=]x" },
  1746. /* BITA 51 */   { 0 , 0, 
  1747.         "85;[1=];" },
  1748. /* BITA 52 */   { 0 , 0, 
  1749.         "a5;" },
  1750. /* BITB 53 */   { ADDR , DIRECT, 
  1751.         "d5;[1=];" },
  1752. /* BITB 54 */   { ADDR , EXTENDED, 
  1753.         "f5;[1=]x" },
  1754. /* BITB 55 */   { 0 , 0, 
  1755.         "c5;[1=];" },
  1756. /* BITB 56 */   { 0 , 0, 
  1757.         "e5;" },
  1758. /* BLE 57 */   { 0 , 0, 
  1759.         "2f;[1=].Q.1+-r" },
  1760. /* BLO 58 */   { 0 , 0, 
  1761.         "25;[1=].Q.1+-r" },
  1762. /* BLS 59 */   { 0 , 0, 
  1763.         "23;[1=].Q.1+-r" },
  1764. /* BLT 60 */   { 0 , 0, 
  1765.         "2d;[1=].Q.1+-r" },
  1766. /* BMI 61 */   { 0 , 0, 
  1767.         "2b;[1=].Q.1+-r" },
  1768. /* BNE 62 */   { 0 , 0, 
  1769.         "26;[1=].Q.1+-r" },
  1770. /* BPL 63 */   { 0 , 0, 
  1771.         "2a;[1=].Q.1+-r" },
  1772. /* BRA 64 */   { 0 , 0, 
  1773.         "20;[1=].Q.1+-r" },
  1774. /* BRN 65 */   { 0 , 0, 
  1775.         "21;[1=].Q.1+-r" },
  1776. /* BSR 66 */   { 0 , 0, 
  1777.         "8d;[1=].Q.1+-r" },
  1778. /* BVC 67 */   { 0 , 0, 
  1779.         "28;[1=].Q.1+-r" },
  1780. /* BVS 68 */   { 0 , 0, 
  1781.         "29;[1=].Q.1+-r" },
  1782. /* CLR 69 */   { ADDR , DIRECT, 
  1783.         "0f;[1=];" },
  1784. /* CLR 70 */   { ADDR , EXTENDED, 
  1785.         "7f;[1=]x" },
  1786. /* CLR 71 */   { 0 , 0, 
  1787.         "6f;" },
  1788. /* CLRA 72 */   { 0 , 0, 
  1789.         "4f;" },
  1790. /* CLRB 73 */   { 0 , 0, 
  1791.         "5f;" },
  1792. /* CMPA 74 */   { ADDR , DIRECT, 
  1793.         "91;[1=];" },
  1794. /* CMPA 75 */   { ADDR , EXTENDED, 
  1795.         "b1;[1=]x" },
  1796. /* CMPA 76 */   { 0 , 0, 
  1797.         "81;[1=];" },
  1798. /* CMPA 77 */   { 0 , 0, 
  1799.         "a1;" },
  1800. /* CMPB 78 */   { ADDR , DIRECT, 
  1801.         "d1;[1=];" },
  1802. /* CMPB 79 */   { ADDR , EXTENDED, 
  1803.         "f1;[1=]x" },
  1804. /* CMPB 80 */   { 0 , 0, 
  1805.         "c1;[1=];" },
  1806. /* CMPB 81 */   { 0 , 0, 
  1807.         "e1;" },
  1808. /* CMPD 82 */   { ADDR , DIRECT, 
  1809.         "10;93;[1=];" },
  1810. /* CMPD 83 */   { ADDR , EXTENDED, 
  1811.         "10;b3;[1=]x" },
  1812. /* CMPD 84 */   { 0 , 0, 
  1813.         "10;83;[1=]x" },
  1814. /* CMPD 85 */   { 0 , 0, 
  1815.         "10;a3;" },
  1816. /* CMPS 86 */   { ADDR , DIRECT, 
  1817.         "11;9c;[1=];" },
  1818. /* CMPS 87 */   { ADDR , EXTENDED, 
  1819.         "11;bc;[1=]x" },
  1820. /* CMPS 88 */   { 0 , 0, 
  1821.         "11;8c;[1=]x" },
  1822. /* CMPS 89 */   { 0 , 0, 
  1823.         "11;ac;" },
  1824. /* CMPU 90 */   { ADDR , DIRECT, 
  1825.         "11;93;[1=];" },
  1826. /* CMPU 91 */   { ADDR , EXTENDED, 
  1827.         "11;b3;[1=]x" },
  1828. /* CMPU 92 */   { 0 , 0, 
  1829.         "11;83;[1=]x" },
  1830. /* CMPU 93 */   { 0 , 0, 
  1831.         "11;a3;" },
  1832. /* CMPX 94 */   { ADDR , DIRECT, 
  1833.         "9c;[1=];" },
  1834. /* CMPX 95 */   { ADDR , EXTENDED, 
  1835.         "bc;[1=]x" },
  1836. /* CMPX 96 */   { 0 , 0, 
  1837.         "8c;[1=]x" },
  1838. /* CMPX 97 */   { 0 , 0, 
  1839.         "ac;" },
  1840. /* CMPY 98 */   { ADDR , DIRECT, 
  1841.         "10;9c;[1=];" },
  1842. /* CMPY 99 */   { ADDR , EXTENDED, 
  1843.         "10;bc;[1=]x" },
  1844. /* CMPY 100 */   { 0 , 0, 
  1845.         "10;8c;[1=]x" },
  1846. /* CMPY 101 */   { 0 , 0, 
  1847.         "10;ac;" },
  1848. /* COM 102 */   { ADDR , DIRECT, 
  1849.         "03;[1=];" },
  1850. /* COM 103 */   { ADDR , EXTENDED, 
  1851.         "73;[1=]x" },
  1852. /* COM 104 */   { 0 , 0, 
  1853.         "63;" },
  1854. /* COMA 105 */   { 0 , 0, 
  1855.         "43;" },
  1856. /* COMB 106 */   { 0 , 0, 
  1857.         "53;" },
  1858. /* CWAI 107 */   { 0 , 0, 
  1859.         "3c;[1=];" },
  1860. /* DAA 108 */   { 0 , 0, 
  1861.         "19;" },
  1862. /* DEC 109 */   { ADDR , DIRECT, 
  1863.         "0a;[1=];" },
  1864. /* DEC 110 */   { ADDR , EXTENDED, 
  1865.         "7a;[1=]x" },
  1866. /* DEC 111 */   { 0 , 0, 
  1867.         "6a;" },
  1868. /* DECA 112 */   { 0 , 0, 
  1869.         "4a;" },
  1870. /* DECB 113 */   { 0 , 0, 
  1871.         "5a;" },
  1872. /* EORA 114 */   { ADDR , DIRECT, 
  1873.         "98;[1=];" },
  1874. /* EORA 115 */   { ADDR , EXTENDED, 
  1875.         "b8;[1=]x" },
  1876. /* EORA 116 */   { 0 , 0, 
  1877.         "88;[1=];" },
  1878. /* EORA 117 */   { 0 , 0, 
  1879.         "a8;" },
  1880. /* EORB 118 */   { ADDR , DIRECT, 
  1881.         "d8;[1=];" },
  1882. /* EORB 119 */   { ADDR , EXTENDED, 
  1883.         "f8;[1=]x" },
  1884. /* EORB 120 */   { 0 , 0, 
  1885.         "c8;[1=];" },
  1886. /* EORB 121 */   { 0 , 0, 
  1887.         "e8;" },
  1888. /* EXG 122 */   { 0 , 0, 
  1889.         "1e;[1#2#];" },
  1890. /* INC 123 */   { ADDR , DIRECT, 
  1891.         "0c;[1=];" },
  1892. /* INC 124 */   { ADDR , EXTENDED, 
  1893.         "7c;[1=]x" },
  1894. /* INC 125 */   { 0 , 0, 
  1895.         "6c;" },
  1896. /* INCA 126 */   { 0 , 0, 
  1897.         "4c;" },
  1898. /* INCB 127 */   { 0 , 0, 
  1899.         "5c;" },
  1900. /* JMP 128 */   { ADDR , DIRECT, 
  1901.         "0e;[1=];" },
  1902. /* JMP 129 */   { ADDR , EXTENDED, 
  1903.         "7e;[1=]x" },
  1904. /* JMP 130 */   { 0 , 0, 
  1905.         "6e;" },
  1906. /* JSR 131 */   { ADDR , DIRECT, 
  1907.         "9d;[1=];" },
  1908. /* JSR 132 */   { ADDR , EXTENDED, 
  1909.         "bd;[1=]x" },
  1910. /* JSR 133 */   { 0 , 0, 
  1911.         "ad;" },
  1912. /* LBCC 134 */   { 0 , 0, 
  1913.         "10;24;[1=].Q.2+-.ffff&x" },
  1914. /* LBCS 135 */   { 0 , 0, 
  1915.         "10;25;[1=].Q.2+-.ffff&x" },
  1916. /* LBEQ 136 */   { 0 , 0, 
  1917.         "10;27;[1=].Q.2+-.ffff&x" },
  1918. /* LBGE 137 */   { 0 , 0, 
  1919.         "10;2c;[1=].Q.2+-.ffff&x" },
  1920. /* LBGT 138 */   { 0 , 0, 
  1921.         "10;2e;[1=].Q.2+-.ffff&x" },
  1922. /* LBHI 139 */   { 0 , 0, 
  1923.         "10;22;[1=].Q.2+-.ffff&x" },
  1924. /* LBHS 140 */   { 0 , 0, 
  1925.         "10;24;[1=].Q.2+-.ffff&x" },
  1926. /* LBLE 141 */   { 0 , 0, 
  1927.         "10;2f;[1=].Q.2+-.ffff&x" },
  1928. /* LBLO 142 */   { 0 , 0, 
  1929.         "10;25;[1=].Q.2+-.ffff&x" },
  1930. /* LBLS 143 */   { 0 , 0, 
  1931.         "10;23;[1=].Q.2+-.ffff&x" },
  1932. /* LBLT 144 */   { 0 , 0, 
  1933.         "10;2d;[1=].Q.2+-.ffff&x" },
  1934. /* LBMI 145 */   { 0 , 0, 
  1935.         "10;2b;[1=].Q.2+-.ffff&x" },
  1936. /* LBNE 146 */   { 0 , 0, 
  1937.         "10;26;[1=].Q.2+-.ffff&x" },
  1938. /* LBPL 147 */   { 0 , 0, 
  1939.         "10;2a;[1=].Q.2+-.ffff&x" },
  1940. /* LBRA 148 */   { 0 , 0, 
  1941.         "16;[1=].Q.2+-.ffff&x" },
  1942. /* LBRN 149 */   { 0 , 0, 
  1943.         "10;21;[1=].Q.2+-.ffff&x" },
  1944. /* LBSR 150 */   { 0 , 0, 
  1945.         "17;[1=].Q.2+-.ffff&x" },
  1946. /* LBVC 151 */   { 0 , 0, 
  1947.         "10;28;[1=].Q.2+-.ffff&x" },
  1948. /* LBVS 152 */   { 0 , 0, 
  1949.         "10;29;[1=].Q.2+-.ffff&x" },
  1950. /* LDA 153 */   { ADDR , DIRECT, 
  1951.         "96;[1=];" },
  1952. /* LDA 154 */   { ADDR , EXTENDED, 
  1953.         "b6;[1=]x" },
  1954. /* LDA 155 */   { 0 , 0, 
  1955.         "86;[1=];" },
  1956. /* LDA 156 */   { 0 , 0, 
  1957.         "a6;" },
  1958. /* LDB 157 */   { ADDR , DIRECT, 
  1959.         "d6;[1=];" },
  1960. /* LDB 158 */   { ADDR , EXTENDED, 
  1961.         "f6;[1=]x" },
  1962. /* LDB 159 */   { 0 , 0, 
  1963.         "c6;[1=];" },
  1964. /* LDB 160 */   { 0 , 0, 
  1965.         "e6;" },
  1966. /* LDD 161 */   { ADDR , DIRECT, 
  1967.         "dc;[1=];" },
  1968. /* LDD 162 */   { ADDR , EXTENDED, 
  1969.         "fc;[1=]x" },
  1970. /* LDD 163 */   { 0 , 0, 
  1971.         "cc;[1=]x" },
  1972. /* LDD 164 */   { 0 , 0, 
  1973.         "ec;" },
  1974. /* LDS 165 */   { ADDR , DIRECT, 
  1975.         "10;de;[1=];" },
  1976. /* LDS 166 */   { ADDR , EXTENDED, 
  1977.         "10;fe;[1=]x" },
  1978. /* LDS 167 */   { 0 , 0, 
  1979.         "10;ce;[1=]x" },
  1980. /* LDS 168 */   { 0 , 0, 
  1981.         "10;ee;" },
  1982. /* LDU 169 */   { ADDR , DIRECT, 
  1983.         "de;[1=];" },
  1984. /* LDU 170 */   { ADDR , EXTENDED, 
  1985.         "fe;[1=]x" },
  1986. /* LDU 171 */   { 0 , 0, 
  1987.         "ce;[1=]x" },
  1988. /* LDU 172 */   { 0 , 0, 
  1989.         "ee;" },
  1990. /* LDX 173 */   { ADDR , DIRECT, 
  1991.         "9e;[1=];" },
  1992. /* LDX 174 */   { ADDR , EXTENDED, 
  1993.         "be;[1=]x" },
  1994. /* LDX 175 */   { 0 , 0, 
  1995.         "8e;[1=]x" },
  1996. /* LDX 176 */   { 0 , 0, 
  1997.         "ae;" },
  1998. /* LDY 177 */   { ADDR , DIRECT, 
  1999.         "10;9e;[1=];" },
  2000. /* LDY 178 */   { ADDR , EXTENDED, 
  2001.         "10;be;[1=]x" },
  2002. /* LDY 179 */   { 0 , 0, 
  2003.         "10;8e;[1=]x" },
  2004. /* LDY 180 */   { 0 , 0, 
  2005.         "10;ae;" },
  2006. /* LEAS 181 */   { 0 , 0, 
  2007.         "32;" },
  2008. /* LEAU 182 */   { 0 , 0, 
  2009.         "33;" },
  2010. /* LEAX 183 */   { 0 , 0, 
  2011.         "30;" },
  2012. /* LEAY 184 */   { 0 , 0, 
  2013.         "31;" },
  2014. /* LSL 185 */   { ADDR , DIRECT, 
  2015.         "08;[1=];" },
  2016. /* LSL 186 */   { ADDR , EXTENDED, 
  2017.         "78;[1=]x" },
  2018. /* LSL 187 */   { 0 , 0, 
  2019.         "68;" },
  2020. /* LSLA 188 */   { 0 , 0, 
  2021.         "48;" },
  2022. /* LSLB 189 */   { 0 , 0, 
  2023.         "58;" },
  2024. /* LSR 190 */   { ADDR , DIRECT, 
  2025.         "04;[1=];" },
  2026. /* LSR 191 */   { ADDR , EXTENDED, 
  2027.         "74;[1=]x" },
  2028. /* LSR 192 */   { 0 , 0, 
  2029.         "64;" },
  2030. /* LSRA 193 */   { 0 , 0, 
  2031.         "44;" },
  2032. /* LSRB 194 */   { 0 , 0, 
  2033.         "54;" },
  2034. /* MUL 195 */   { 0 , 0, 
  2035.         "3d;" },
  2036. /* NEG 196 */   { ADDR , DIRECT, 
  2037.         "00;[1=];" },
  2038. /* NEG 197 */   { ADDR , EXTENDED, 
  2039.         "70;[1=]x" },
  2040. /* NEG 198 */   { 0 , 0, 
  2041.         "60;" },
  2042. /* NEGA 199 */   { 0 , 0, 
  2043.         "40;" },
  2044. /* NEGB 200 */   { 0 , 0, 
  2045.         "50;" },
  2046. /* NOP 201 */   { 0 , 0, 
  2047.         "12;" },
  2048. /* ORA 202 */   { ADDR , DIRECT, 
  2049.         "9a;[1=];" },
  2050. /* ORA 203 */   { ADDR , EXTENDED, 
  2051.         "ba;[1=]x" },
  2052. /* ORA 204 */   { 0 , 0, 
  2053.         "8a;[1=];" },
  2054. /* ORA 205 */   { 0 , 0, 
  2055.         "aa;" },
  2056. /* ORB 206 */   { ADDR , DIRECT, 
  2057.         "da;[1=];" },
  2058. /* ORB 207 */   { ADDR , EXTENDED, 
  2059.         "fa;[1=]x" },
  2060. /* ORB 208 */   { 0 , 0, 
  2061.         "ca;[1=];" },
  2062. /* ORB 209 */   { 0 , 0, 
  2063.         "ea;" },
  2064. /* ORCC 210 */   { 0 , 0, 
  2065.         "1a;[1=];" },
  2066. /* PSHS 211 */   { 0 , 0, 
  2067.         "34;[1#];" },
  2068. /* PSHU 212 */   { 0 , 0, 
  2069.         "36;[1#];" },
  2070. /* PULS 213 */   { 0 , 0, 
  2071.         "35;[1#];" },
  2072. /* PULU 214 */   { 0 , 0, 
  2073.         "37;[1#];" },
  2074. /* ROL 215 */   { ADDR , DIRECT, 
  2075.         "09;[1=];" },
  2076. /* ROL 216 */   { ADDR , EXTENDED, 
  2077.         "79;[1=]x" },
  2078. /* ROL 217 */   { 0 , 0, 
  2079.         "69;" },
  2080. /* ROLA 218 */   { 0 , 0, 
  2081.         "49;" },
  2082. /* ROLB 219 */   { 0 , 0, 
  2083.         "59;" },
  2084. /* ROR 220 */   { ADDR , DIRECT, 
  2085.         "06;[1=];" },
  2086. /* ROR 221 */   { ADDR , EXTENDED, 
  2087.         "76;[1=]x" },
  2088. /* ROR 222 */   { 0 , 0, 
  2089.         "66;" },
  2090. /* RORA 223 */   { 0 , 0, 
  2091.         "46;" },
  2092. /* RORB 224 */   { 0 , 0, 
  2093.         "56;" },
  2094. /* RTI 225 */   { 0 , 0, 
  2095.         "3b;" },
  2096. /* RTS 226 */   { 0 , 0, 
  2097.         "39;" },
  2098. /* SBCA 227 */   { ADDR , DIRECT, 
  2099.         "92;[1=];" },
  2100. /* SBCA 228 */   { ADDR , EXTENDED, 
  2101.         "b2;[1=]x" },
  2102. /* SBCA 229 */   { 0 , 0, 
  2103.         "82;[1=];" },
  2104. /* SBCA 230 */   { 0 , 0, 
  2105.         "a2;" },
  2106. /* SBCB 231 */   { ADDR , DIRECT, 
  2107.         "d2;[1=];" },
  2108. /* SBCB 232 */   { ADDR , EXTENDED, 
  2109.         "f2;[1=]x" },
  2110. /* SBCB 233 */   { 0 , 0, 
  2111.         "c2;[1=];" },
  2112. /* SBCB 234 */   { 0 , 0, 
  2113.         "e2;" },
  2114. /* SEX 235 */   { 0 , 0, 
  2115.         "1d;" },
  2116. /* STA 236 */   { ADDR , DIRECT, 
  2117.         "97;[1=];" },
  2118. /* STA 237 */   { ADDR , EXTENDED, 
  2119.         "b7;[1=]x" },
  2120. /* STA 238 */   { 0 , 0, 
  2121.         "a7;" },
  2122. /* STB 239 */   { ADDR , DIRECT, 
  2123.         "d7;[1=];" },
  2124. /* STB 240 */   { ADDR , EXTENDED, 
  2125.         "f7;[1=]x" },
  2126. /* STB 241 */   { 0 , 0, 
  2127.         "e7;" },
  2128. /* STD 242 */   { ADDR , DIRECT, 
  2129.         "dd;[1=];" },
  2130. /* STD 243 */   { ADDR , EXTENDED, 
  2131.         "fd;[1=]x" },
  2132. /* STD 244 */   { 0 , 0, 
  2133.         "ed;" },
  2134. /* STS 245 */   { ADDR , DIRECT, 
  2135.         "10;df;[1=];" },
  2136. /* STS 246 */   { ADDR , EXTENDED, 
  2137.         "10;ff;[1=]x" },
  2138. /* STS 247 */   { 0 , 0, 
  2139.         "10;ef;" },
  2140. /* STU 248 */   { ADDR , DIRECT, 
  2141.         "df;[1=];" },
  2142. /* STU 249 */   { ADDR , EXTENDED, 
  2143.         "ff;[1=]x" },
  2144. /* STU 250 */   { 0 , 0, 
  2145.         "ef;" },
  2146. /* STX 251 */   { ADDR , DIRECT, 
  2147.         "9f;[1=];" },
  2148. /* STX 252 */   { ADDR , EXTENDED, 
  2149.         "bf;[1=]x" },
  2150. /* STX 253 */   { 0 , 0, 
  2151.         "af;" },
  2152. /* STY 254 */   { ADDR , DIRECT, 
  2153.         "10;9f;[1=];" },
  2154. /* STY 255 */   { ADDR , EXTENDED, 
  2155.         "10;bf;[1=]x" },
  2156. /* STY 256 */   { 0 , 0, 
  2157.         "10;af;" },
  2158. /* SUBA 257 */   { ADDR , DIRECT, 
  2159.         "90;[1=];" },
  2160. /* SUBA 258 */   { ADDR , EXTENDED, 
  2161.         "b0;[1=]x" },
  2162. /* SUBA 259 */   { 0 , 0, 
  2163.         "80;[1=];" },
  2164. /* SUBA 260 */   { 0 , 0, 
  2165.         "a0;" },
  2166. /* SUBB 261 */   { ADDR , DIRECT, 
  2167.         "d0;[1=];" },
  2168. /* SUBB 262 */   { ADDR , EXTENDED, 
  2169.         "f0;[1=]x" },
  2170. /* SUBB 263 */   { 0 , 0, 
  2171.         "c0;[1=];" },
  2172. /* SUBB 264 */   { 0 , 0, 
  2173.         "e0;" },
  2174. /* SUBD 265 */   { ADDR , DIRECT, 
  2175.         "93;[1=];" },
  2176. /* SUBD 266 */   { ADDR , EXTENDED, 
  2177.         "b3;[1=]x" },
  2178. /* SUBD 267 */   { 0 , 0, 
  2179.         "83;[1=]x" },
  2180. /* SUBD 268 */   { 0 , 0, 
  2181.         "a3;" },
  2182. /* SWI2 269 */   { 0 , 0, 
  2183.         "10;3f;" },
  2184. /* SWI3 270 */   { 0 , 0, 
  2185.         "11;3f;" },
  2186. /* SWI 271 */   { 0 , 0, 
  2187.         "3f;" },
  2188. /* SYNC 272 */   { 0 , 0, 
  2189.         "13;" },
  2190. /* TFR 273 */   { 0 , 0, 
  2191.         "1f;[1#2#];" },
  2192. /* TST 274 */   { ADDR , DIRECT, 
  2193.         "0d;[1=];" },
  2194. /* TST 275 */   { ADDR , EXTENDED, 
  2195.         "7d;[1=]x" },
  2196. /* TST 276 */   { 0 , 0, 
  2197.         "6d;" },
  2198. /* TSTA 277 */   { 0 , 0, 
  2199.         "4d;" },
  2200. /* TSTB 278 */   { 0 , 0, 
  2201.         "5d;" },
  2202.     { 0,0,""} };
  2203. /* end fraptabdef.c */
  2204.